//64位超前进位加法器将两个16位超前进位加法器进行级联，并超前计算进位
module adder_64_head
(
	input [63:0]a,// 64位输入
	input [63:0]b,// 64位输入
	input cin,//低位进位
	output [63:0]result,//64位结果
	output cout64//64位进位

);
wire [3:0] gx;
wire [3:0] px;
wire [4:1]cout2;
wire [63:0]p;
wire [63:0]g;
//将4位全加器例化4次，形成16位加法器
adder_16_head c0
(
	.a(a[15:0]),
	.b(b[15:0]),
	.cin(cin),
	.result(result[15:0]),
	.g16(gx[0]),
	.p16(px[0]),
	.g(g[15:0]),
	.p(p[15:0])
);
adder_16_head c1
(
	.a(a[31:16]),
	.b(b[31:16]),
	.cin(cout2[1]),
	.result(result[31:16]),
	.g16(gx[1]),
	.p16(px[1]),
	.g(g[31:16]),
	.p(p[31:16])
);
adder_16_head c2
(
	.a(a[47:32]),
	.b(b[47:32]),
	.cin(cout2[2]),
	.result(result[47:32]),
	.g16(gx[2]),
	.p16(px[2]),
	.g(g[47:32]),
	.p(p[47:32])
);
adder_16_head c3
(
	.a(a[63:48]),
	.b(b[63:48]),
	.cin(cout2[3]),
	.result(result[63:48]),
	.g16(gx[3]),
	.p16(px[3]),
	.g(g[63:48]),
	.p(p[63:48])
);
CLA_4 cc4
(
	.p(px),
	.g(gx),
	.cin(cin),
	.cout(cout2),
	.g4(g4),
	.p4(p4)
);
//这里直接写门电路计算超前进位
assign cout64=cout2[4];
endmodule

module adder_1//一位全加器
(
	input a,// 1位输入
	input b,// 1位输入
	input cin,//低位进位
	output result,//结果
	output g,//进位产生
	output p//进位传递
);
assign result=a^b^cin;
assign g=a&b;
assign p=a|b;
endmodule

module CLA_4//4位并行产生进位的CLA
(
	input [3:0] p,//进位产生
	input [3:0] g,//进为传递
	input cin,//低位进位
	output [4:1]cout,//进位
	output g4,//四位超前进位加法器进位产生
	output p4//四位超前进位加法器进位传递
);
assign cout[1]= g[0]|p[0]&cin;
assign cout[2]= g[1]|p[1]&g[0]|p[1]&p[0]&cin;
assign cout[3]= g[2]|p[2]&g[1]|p[2]&p[1]&g[0]|p[2]&p[1]&p[0]&cin;
assign cout[4]= g[3]|p[3]&g[2]|p[3]&p[2]&g[1]||p[3]&p[2]&p[1]&g[0]||p[3]&p[2]&p[1]&p[0]&cin;//四位超前的进位计算
assign g4= g[3]|p[3]&g[2]|p[3]&p[2]&g[1]||p[3]&p[2]&p[1]&g[0];
assign p4= p[3]&p[2]&p[1]&p[0]&cin;
endmodule

module adder_4_head
(
	input [3:0]a,// 4位输入
	input [3:0]b,// 4位输入
	input cin,//低位进位
	output [3:0]result,//4位结果
	output g4,//进位产生
	output p4,//进位传递	
	output [3:0]g,//按位或
	output [3:0]p//按位与
);
wire [4:1]cout;
//将1位全加器例化4次，形成四位加法器
adder_1 a0
(
	.a(a[0]),
	.b(b[0]),
	.cin(cin),
	.result(result[0]),
	.g(g[0]),
	.p(p[0])
);
adder_1 a1
(
	.a(a[1]),
	.b(b[1]),
	.cin(cout[1]),
	.result(result[1]),
	.g(g[1]),
	.p(p[1])
);
adder_1 a2
(
	.a(a[2]),
	.b(b[2]),
	.cin(cout[2]),
	.result(result[2]),
	.g(g[2]),
	.p(p[2])
);
adder_1 a3
(
	.a(a[3]),
	.b(b[3]),
	.cin(cout[3]),
	.result(result[3]),
	.g(g[3]),
	.p(p[3])
);
//并行计算提供超前进位
CLA_4 c4
(
	.p(p),
	.g(g),
	.cin(cin),
	.cout(cout),
	.g4(g4),
	.p4(p4)
);
endmodule

//16位超前进位加法器并非真正意义上的超前进位加法器，是将4个四位超前进位加法器进行超前计算进位，比严格的16位超前进位加法器延时会更高一些，但是严格的16位超前加法器依赖于很大驱动信号，和门的输入变得很多，在实用中反而会增加更大延时。
module adder_16_head
(
	input [15:0]a,// 16位输入
	input [15:0]b,// 16位输入
	input cin,//低位进位
	output [15:0]result,//16位结果
	output g16,//进位产生
	output p16,//进位传递
	output [15:0]g,//按位或
	output [15:0]p//按位与

);
wire [3:0] g4;
wire [3:0] p4;
wire [4:1] cout1;
//将4位全加器例化4次，形成16位加法器
adder_4_head b0
(
	.a(a[3:0]),
	.b(b[3:0]),
	.cin(cin),
	.result(result[3:0]),
	.g4(g4[0]),
	.p4(p4[0]),
	.g(g[3:0]),
	.p(p[3:0])
);
adder_4_head b1
(
	.a(a[7:4]),
	.b(b[7:4]),
	.cin(cout1[1]),
	.result(result[7:4]),
	.g4(g4[1]),
	.p4(p4[1]),
	.g(g[7:4]),
	.p(p[7:4])
);
adder_4_head b2
(
	.a(a[11:8]),
	.b(b[11:8]),
	.cin(cout1[2]),
	.result(result[11:8]),
	.g4(g4[2]),
	.p4(p4[2]),
	.g(g[11:8]),
	.p(p[11:8])
);
adder_4_head b4
(
	.a(a[15:12]),
	.b(b[15:12]),
	.cin(cout1[3]),
	.result(result[15:12]),
	.g4(g4[3]),
	.p4(p4[3]),
	.g(g[15:12]),
	.p(p[15:12])
);
//并行计算提供超前进位
CLA_4 c16
(
	.p(p4),
	.g(g4),
	.cin(cin),
	.cout(cout1),
	.g4(g16),
	.p4(p16)
);
endmodule

